import java.util.*;
/**
 * 判断链表是否为回文链表
 * 算法步骤：
 * 1. 使用快慢指针找到链表中点
 * 2. 反转后半部分链表
 * 3. 比较前半部分和反转后的后半部分
 * 时间复杂度O(n)，空间复杂度O(1)
 */
public class isPalindrome {
    /**
     * 链表节点类
     * 包含节点值和指向下一个节点的引用
     */
    public static class ListNode{
        int val;        // 节点值
        ListNode next;  // 指向下一个节点的引用
        
        // 无参构造函数
        ListNode(){}
        
        // 带值的构造函数
        ListNode(int val){
            this.val = val;
        }
        
        // 带值和下一个节点的构造函数
        ListNode(int val, ListNode next){
            this.val = val;
            this.next = next;
        }
    }

    /**
     * 判断链表是否为回文链表的方法
     * 使用快慢指针找到中点，反转后半部分后比较
     * 
     * @param head 链表头节点
     * @return 是否为回文链表
     */
    public static boolean isPalindromeM(ListNode head){
        // 创建虚拟头节点，简化操作
        ListNode dummy = new ListNode(-1, head);
        
        // 处理特殊情况：空链表或单节点链表
        if(head == null || head.next == null) return true;
        
        // 使用快慢指针找到链表中点
        ListNode slow = dummy.next;  // 慢指针，最终指向中点
        ListNode fast = head.next;   // 快指针从head.next开始，这样在偶数长度链表时，慢指针会停在第一个中间节点
                                    // 例如：1->2->2->1，slow最终停在第一个2
                                    // 在奇数长度链表时，slow会停在中点
                                    // 例如：1->2->3->2->1，slow最终停在3
        while(fast != null && fast.next != null){
            fast = fast.next.next;   // 快指针移动两步
            slow = slow.next;        // 慢指针移动一步
        }
        
        // 反转后半部分链表
        ListNode head2 = reverseList(slow.next);
        slow.next = null;  // 断开前后两部分
        
        // 比较前半部分和反转后的后半部分
        boolean result = compare2List(head, head2);
        return result;
    }

    /**
     * 反转链表的方法
     * 使用迭代方法实现链表反转
     * 
     * @param head 要反转的链表头节点
     * @return 反转后的链表头节点
     */
    public static ListNode reverseList(ListNode head){
        ListNode pre = null;   // 前一个节点
        ListNode tmp = null;   // 临时节点，用于保存下一个节点
        while(head != null){
            tmp = head.next;      // 保存下一个节点
            head.next = pre;      // 反转当前节点的指向
            pre = head;           // 移动pre指针
            head = tmp;           // 移动head指针
        }
        return pre;  // 返回反转后的头节点
    }

    /**
     * 比较两个链表是否相同的方法
     * 逐个节点比较值是否相等
     * 
     * @param head1 第一个链表头节点
     * @param head2 第二个链表头节点
     * @return 两个链表是否相同
     */
    public static boolean compare2List(ListNode head1, ListNode head2){
        while(head1 != null && head2 != null){
            if(head1.val != head2.val) return false;  // 发现不同值，返回false
            head1 = head1.next;  // 移动第一个链表指针
            head2 = head2.next;  // 移动第二个链表指针
        }
        return true;  // 所有节点都相同，返回true
    }

    /**
     * 主函数：处理输入输出
     * 输入格式：一行数字，用空格分隔，表示链表节点值
     */
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        // 读取链表节点值
        String[] s = sc.nextLine().split(" ");
        
        // 创建链表
        ListNode dummy = new ListNode(-1);  // 虚拟头节点
        ListNode node = dummy;
        for(int i = 0; i < s.length; i++){
            node.next = new ListNode(Integer.parseInt(s[i]));
            node = node.next;
        }
        
        // 判断是否为回文链表并输出结果
        boolean result = isPalindromeM(dummy.next);
        System.out.println(result);
        sc.close();
    }
}
